const axios = require('axios');

// 基础URL配置
const BASE_URL = 'http://localhost:3000/api';
const AUTH_URL = `${BASE_URL}/auth`;
const MODEL_URL = `${BASE_URL}/models`;

// 测试用户凭据
const TEST_USER = {
    username: 'admin',
    password: '123456',
    email: '525675049@qq.com'
};

// 全局变量
let accessToken = '';
let testModelId = '';

// 控制台日志颜色
const colors = {
    reset: '\x1b[0m',
    green: '\x1b[32m',
    red: '\x1b[31m',
    yellow: '\x1b[33m',
    blue: '\x1b[34m',
    magenta: '\x1b[35m'
};

/**
 * 格式化日志输出
 */
function logSection(title) {
    console.log(`\n${colors.magenta}===== ${title} =====${colors.reset}`);
}

function logSuccess(message) {
    console.log(`${colors.green}✅ ${message}${colors.reset}`);
}

function logError(message, error) {
    console.log(`${colors.red}❌ ${message}${colors.reset}`);
    if (error.response) {
        console.log(`状态码: ${error.response.status}`);
        console.log(`错误信息:`, error.response.data);
    } else if (error.request) {
        console.log('无法连接到服务器，请确保服务器正在运行');
    } else {
        console.log(`请求错误: ${error.message}`);
    }
}

function logInfo(message) {
    console.log(`${colors.blue}ℹ️ ${message}${colors.reset}`);
}

/**
 * 注册测试用户
 */
async function registerTestUser() {
    logSection('注册测试用户');

    try {
        await axios.post(`${AUTH_URL}/register`, TEST_USER);
        logSuccess(`用户 "${TEST_USER.username}" 注册成功`);
        return true;
    } catch (error) {
        if (error.response && error.response.status === 409) {
            logInfo(`用户 "${TEST_USER.username}" 已存在，继续测试`);
            return true;
        }
        logError('注册测试用户失败', error);
        return false;
    }
}

/**
 * 登录测试用户
 */
async function loginTestUser() {
    logSection('登录测试用户');

    try {
        const response = await axios.post(`${AUTH_URL}/login`, {
            username: TEST_USER.username,
            password: TEST_USER.password
        });

        accessToken = response.data.data.token;
        logSuccess(`用户 "${TEST_USER.username}" 登录成功`);
        logInfo(`访问令牌: ${accessToken.substring(0, 15)}...`);
        return true;
    } catch (error) {
        logError('登录测试用户失败', error);
        return false;
    }
}

/**
 * 获取几何体类型
 */
async function getGeometryTypes() {
    logSection('获取几何体类型');

    try {
        const response = await axios.get(`${MODEL_URL}/geometry-types`, {
            headers: { Authorization: `Bearer ${accessToken}` }
        });

        logSuccess('获取几何体类型成功');
        console.log('几何体类型:', response.data.data);
        return response.data.data;
    } catch (error) {
        logError('获取几何体类型失败', error);
        return null;
    }
}

/**
 * 创建立方体模型
 */
async function createCubeModel() {
    logSection('创建立方体模型');

    const modelData = {
        name: '测试立方体',
        description: '这是一个测试立方体模型',
        geometry: {
            type: 'cube',
            color: '#FF0000',
            dimensions: {
                width: 2,
                height: 2,
                depth: 2
            },
            position: {
                x: 0,
                y: 0,
                z: 0
            },
            rotation: {
                x: 0,
                y: 0,
                z: 0
            }
        }
    };

    try {
        const response = await axios.post(MODEL_URL, modelData, {
            headers: { Authorization: `Bearer ${accessToken}` }
        });

        testModelId = response.data.data.modelId;
        logSuccess('创建立方体模型成功');
        logInfo(`模型ID: ${testModelId}`);
        return true;
    } catch (error) {
        logError('创建立方体模型失败', error);
        return false;
    }
}

/**
 * 创建球体模型
 */
async function createSphereModel() {
    logSection('创建球体模型');

    const modelData = {
        name: '测试球体',
        description: '这是一个测试球体模型',
        geometry: {
            type: 'sphere',
            color: '#0000FF',
            dimensions: {
                radius: 1.5,
                segments: 32
            },
            position: {
                x: 0,
                y: 0,
                z: 0
            },
            rotation: {
                x: 0,
                y: 0,
                z: 0
            }
        }
    };

    try {
        const response = await axios.post(MODEL_URL, modelData, {
            headers: { Authorization: `Bearer ${accessToken}` }
        });

        const sphereModelId = response.data.data.modelId;
        logSuccess('创建球体模型成功');
        logInfo(`模型ID: ${sphereModelId}`);
        return true;
    } catch (error) {
        logError('创建球体模型失败', error);
        return false;
    }
}

/**
 * 获取模型列表
 */
async function getModels() {
    logSection('获取模型列表');

    try {
        const response = await axios.get(MODEL_URL, {
            headers: { Authorization: `Bearer ${accessToken}` }
        });

        logSuccess('获取模型列表成功');
        console.log('模型列表:', response.data.data.map(model => ({
            id: model.id,
            name: model.name,
            geometryType: model.geometry?.type
        })));
        return response.data.data;
    } catch (error) {
        logError('获取模型列表失败', error);
        return null;
    }
}

/**
 * 获取模型缩略图
 */
async function getModelThumbnail() {
    logSection('获取模型缩略图');

    if (!testModelId) {
        logError('无法获取缩略图，模型ID不存在');
        return false;
    }

    try {
        const response = await axios.get(`${MODEL_URL}/${testModelId}/thumbnail`, {
            headers: { Authorization: `Bearer ${accessToken}` }
        });

        logSuccess('获取模型缩略图成功');
        console.log('缩略图信息:', {
            status: response.data.status,
            thumbnailLength: response.data.data.thumbnail.substring(0, 30) + '...'
        });
        return true;
    } catch (error) {
        logError('获取模型缩略图失败', error);
        return false;
    }
}

/**
 * 更新模型几何体
 */
async function updateModelGeometry() {
    logSection('更新模型几何体');

    if (!testModelId) {
        logError('无法更新模型，模型ID不存在');
        return false;
    }

    const updateData = {
        geometry: {
            type: 'cube',
            color: '#00FF00', // 改为绿色
            dimensions: {
                width: 3,      // 改为更大的尺寸
                height: 3,
                depth: 3
            },
            position: {
                x: 1,          // 改变位置
                y: 1,
                z: 1
            },
            rotation: {
                x: 45,         // 添加旋转
                y: 45,
                z: 0
            }
        }
    };

    try {
        const response = await axios.put(`${MODEL_URL}/${testModelId}`, updateData, {
            headers: { Authorization: `Bearer ${accessToken}` }
        });

        logSuccess('更新模型几何体成功');
        console.log('响应数据:', response.data);
        return true;
    } catch (error) {
        logError('更新模型几何体失败', error);
        return false;
    }
}

/**
 * 删除测试模型
 */
async function deleteTestModel() {
    logSection('删除测试模型');

    if (!testModelId) {
        logError('无法删除模型，模型ID不存在');
        return false;
    }

    try {
        const response = await axios.delete(`${MODEL_URL}/${testModelId}`, {
            headers: { Authorization: `Bearer ${accessToken}` }
        });

        logSuccess('删除测试模型成功');
        console.log('响应数据:', response.data);
        return true;
    } catch (error) {
        logError('删除测试模型失败', error);
        return false;
    }
}

/**
 * 运行所有测试
 */
async function runAllTests() {
    console.log(`${colors.yellow}==============================${colors.reset}`);
    console.log(`${colors.yellow}开始几何体模型测试${colors.reset}`);
    console.log(`${colors.yellow}==============================${colors.reset}`);

    try {
        // 用户认证
        if (!(await registerTestUser())) return;
        if (!(await loginTestUser())) return;

        // 获取几何体类型
        await getGeometryTypes();

        // 创建几何体模型
        if (!(await createCubeModel())) return;
        await createSphereModel();

        // 查看模型列表
        await getModels();

        // 获取模型缩略图
        await getModelThumbnail();

        // 更新模型几何体
        await updateModelGeometry();

        // 清理测试数据
        await deleteTestModel();

        console.log(`\n${colors.green}==============================${colors.reset}`);
        console.log(`${colors.green}几何体模型测试完成${colors.reset}`);
        console.log(`${colors.green}==============================${colors.reset}`);
    } catch (error) {
        console.error(`${colors.red}测试过程中发生错误:${colors.reset}`, error);
    }
}

// 执行测试
runAllTests(); 